package flare.display
{
  import flare.util.Colors;

  /**
   * A Sprite representing a rectangle shape. Supports line and fill colors
   * and rounded corners.
   */
  public class RectSprite extends DirtySprite
  {
    /** @private */
    protected var _w:Number;
    /** @private */
    protected var _h:Number;
    /** @private */
    protected var _cw:Number = 0;
    /** @private */
    protected var _ch:Number = 0;
    /** @private */
    protected var _fillColor:uint = 0x00ffffff;
    /** @private */
    protected var _lineColor:uint = 0xffaaaaaa;
    /** @private */
    protected var _lineWidth:Number = 0;
    /** @private */
    protected var _pixelHinting:Boolean = true;

    /** The width of the rectangle. */
    public function get w():Number
    {
      return _w;
    }

    public function set w(v:Number):void
    {
      _w = v;
      dirty();
    }

    /** The height of the rectangle. */
    public function get h():Number
    {
      return _h;
    }

    public function set h(v:Number):void
    {
      _h = v;
      dirty();
    }

    /** The width of rounded corners. Zero indicates no rounding. */
    public function get cornerWidth():Number
    {
      return _cw;
    }

    public function set cornerWidth(v:Number):void
    {
      _cw = v;
      dirty();
    }

    /** The height of rounded corners. Zero indicates no rounding. */
    public function get cornerHeight():Number
    {
      return _ch;
    }

    public function set cornerHeight(v:Number):void
    {
      _ch = v;
      dirty();
    }

    /** Sets corner width and height simultaneously. */
    public function set cornerSize(v:Number):void
    {
      _cw = _ch = v;
      dirty();
    }

    /** The fill color of the rectangle. */
    public function get fillColor():uint
    {
      return _fillColor;
    }

    public function set fillColor(c:uint):void
    {
      _fillColor = c;
      dirty();
    }

    /** The line color of the rectangle outline. */
    public function get lineColor():uint
    {
      return _lineColor;
    }

    public function set lineColor(c:uint):void
    {
      _lineColor = c;
      dirty();
    }

    /** The line width of the rectangle outline. */
    public function get lineWidth():Number
    {
      return _lineWidth;
    }

    public function set lineWidth(v:Number):void
    {
      _lineWidth = v;
      dirty();
    }

    /** Flag indicating if pixel hinting should be used for the outline. */
    public function get linePixelHinting():Boolean
    {
      return _pixelHinting;
    }

    public function set linePixelHinting(b:Boolean):void
    {
      _pixelHinting = b;
      dirty();
    }

    /**
     * Creates a new RectSprite.
     * @param x the x-coordinate of the top-left corner of the rectangle
     * @param y the y-coordinate of the top-left corder of the rectangle
     * @param w the width of the rectangle
     * @param h the height of the rectangle
     * @param cw the width of rounded corners (zero for no rounding)
     * @param ch the height of rounded corners (zero for no rounding)
     */
    public function RectSprite(x:Number = 0, y:Number = 0, w:Number = 0, h:Number = 0, cw:Number = 0, ch:Number = 0)
    {
      this.x = x;
      this.y = y;
      this._w = w;
      this._h = h;
      this._cw = cw;
      this._ch = ch;
    }

    /** @inheritDoc */
    public override function render():void
    {
      graphics.clear();

      if(isNaN(_w) || isNaN(_h))return;

      var la:Number = Colors.a(_lineColor) / 255;
      var fa:Number = Colors.a(_fillColor) / 255;
      var lc:uint = _lineColor & 0x00ffffff;
      var fc:uint = _fillColor & 0x00ffffff;

      if(la > 0)graphics.lineStyle(_lineWidth, lc, la, _pixelHinting);
      graphics.beginFill(fc, fa);

      if(_cw > 0 || _ch > 0)
      {
        graphics.drawRoundRect(0, 0, _w, _h, _cw, _ch);
      }

      else
      {
        graphics.drawRect(0, 0, _w, _h);
      }
      graphics.endFill();
    }
  } // end of class RectSprite
}